﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MySql.Data;
using MySql.Data.MySqlClient;
using System.Web.Configuration;
using System.Data;

namespace Site.Data
{
    /// <summary>
    /// Permite a aplicação acessar o banco de dados
    /// </summary>
    public abstract class DataAccess
    {
        #region Campos
        MySqlCommand _cmdCommand;//Objeto command para executar comandos SQL no banco
        #endregion

        #region IDisposable Members
        [NonSerialized]
        private bool Disposed = false;
        /// <summary>
        /// Destructor da classe. Executa o método Dispose() para liberar recursos.
        /// </summary>
        ~DataAccess()
        {
            this.Dispose();
        }
        /// <summary>
        /// Libera os recursos usados pela classe. Implementa o método Dispose().
        /// </summary>
        public void Dispose()
        {
            // Para o garbage collector para limpesa. Cleaning up twice.
            Dispose(true);
            GC.SuppressFinalize(this);
        }
        /// <summary>
        /// Libera os recursos usados pela classe. Evita que um objeto seja liberado duas vezes.
        /// </summary>
        /// <param name="disposing"></param>
        private void Dispose(bool disposing)
        {
            // Executa tarefas de limpesa antes de finalizar a classe.
            if (!this.Disposed)
            {
                if (disposing)
                {
                    _cmdCommand.Dispose();
                }
                //free unmanaged resources
            }
            Disposed = true;
        }

        #endregion

        #region Contrutores
        /// <summary>
        /// Inicializa a classe
        /// </summary>
        public DataAccess()
        {
            _cmdCommand = new MySqlCommand();
            _cmdCommand.CommandTimeout = DataAccessCommandTimeout;
        }
        #endregion

        #region Propriedadades

        /// <summary>
        /// Coleção de parametros para executar uma Stored Procedure
        /// </summary>
        protected MySqlParameterCollection DataAccessParameters
        {
            get { return _cmdCommand.Parameters; }
        }

        /// <summary>
        /// Define um Timeout para os comandos SQL
        /// </summary>
        protected int CommandTimeout
        {
            get { return _cmdCommand.CommandTimeout; }
            set { _cmdCommand.CommandTimeout = value; }
        }

        /// <summary>
        /// Retorna o CommandTimeout espeficicado no web.config. Caso não exista o defaul é 300.
        /// </summary>
        internal static int DataAccessCommandTimeout
        {
            get
            {
                //verifica se existe um string de conexão definida no AppSettings
                if (System.Web.Configuration.WebConfigurationManager.AppSettings["WebCommandTimeout"] == null)
                {
                    return 300;
                }
                else
                {
                    return Convert.ToInt32(System.Web.Configuration.WebConfigurationManager.AppSettings["WebCommandTimeout"]);
                }
            }
        }
        #endregion

        #region Métodos
        /// <summary>
        /// Cria um objeto Connection com base na connectionstring passada
        /// </summary>
        /// <param name="peConnection">Nome da string de Conexão no Web.Config</param>
        /// <returns></returns>
        private static MySqlConnection RetornarConexao(StringConnections peConnection)
        {
            //verifica se a string de conexão existe no arquivo de configuração
            if (WebConfigurationManager.ConnectionStrings[peConnection.ToString()] == null) throw new Exception("Não existe a connectionstring " + peConnection.ToString() + " no arquivo de configuração (Web.Config ou App.config)");
            return new MySqlConnection(WebConfigurationManager.ConnectionStrings[peConnection.ToString()].ConnectionString);//objeto de conexão
        }
        /// <summary>
        /// copia os parametros do objeto command para o objeto command da transação
        /// </summary>
        /// <param name="trTransaction">Objeto de transação</param>
        private void CopiarParametros(ref DataTransaction trTransaction_)
        {
            int intCont = 0;
            trTransaction_.Command.Parameters.Clear();

            //percorre os parametros do objeto command para colocar no objeto command da transação
            for (intCont = 0; intCont <= _cmdCommand.Parameters.Count - 1; intCont++)
            {
                trTransaction_.Command.Parameters.Add(_cmdCommand.Parameters[intCont].ParameterName,
                                                     _cmdCommand.Parameters[intCont].MySqlDbType,
                                                     _cmdCommand.Parameters[intCont].Size
                                                    ).Value = _cmdCommand.Parameters[intCont].Value;
                trTransaction_.Command.Parameters[intCont].Direction = _cmdCommand.Parameters[intCont].Direction;

            }
        }
        /// <summary>
        /// copia os valores de retorno dos parametros do objeto de transação para o objeto command
        /// </summary>
        /// <param name="trTransaction">Objeto de transação</param>
        private void AtualizarParametros(DataTransaction trTransaction_)
        {
            int intCont = 0;

            _cmdCommand.Parameters.Clear();//limpa os parametros pq o mesmo pode ser utilizado para executar uma outra proc sem estar na transação com parametros diferentes                 

            //percorre os parametros do objeto command para colocar no objeto command da transação
            for (intCont = 0; intCont <= trTransaction_.Command.Parameters.Count - 1; intCont++)
            {
                _cmdCommand.Parameters.Add(trTransaction_.Command.Parameters[intCont].ParameterName,
                                           trTransaction_.Command.Parameters[intCont].MySqlDbType,
                                           trTransaction_.Command.Parameters[intCont].Size
                                          ).Value = trTransaction_.Command.Parameters[intCont].Value;
                _cmdCommand.Parameters[intCont].Direction = trTransaction_.Command.Parameters[intCont].Direction;
            }
        }
        /// <summary>
        /// Cria uma Transação
        /// </summary>        
        /// <returns>Objeto de Transação</returns>
        protected DataTransaction CreateTransaction()
        {
            return new DataTransaction(RetornarConexao(StringConnections.BeloSalao));
        }
        /// <summary>
        /// Cria uma Transação
        /// </summary>
        /// <param name="peConnection">String de Conexão</param>
        /// <returns>Objeto de Transação</returns>
        protected DataTransaction CreateTransaction(StringConnections peConnection)
        {
            return new DataTransaction(RetornarConexao(peConnection));
        }
        /// <summary>
        /// Cria uma Transação
        /// </summary>
        /// <param name="peConnection">String de Conexão</param>
        /// <param name="enumLevel_">Isolation Level da transação</param>
        /// <returns>Objeto de Transação</returns>
        protected DataTransaction CreateTransaction(StringConnections peConnection, IsolationLevel enumLevel_)
        {
            return new DataTransaction(RetornarConexao(peConnection), enumLevel_);
        }
        /// <summary>
        /// Retorna o resultado de um comando SQL (Procedure e Transact-SQL) em um DataTable.
        /// </summary>
        /// <param name="pstrCommand">Nome da StoredProcedure</param>
        /// <returns>DataTable com o resultado do comando SQL.</returns>
        protected DataTable ExecuteDataTable(string pstrCommand)
        {
            return ExecuteDataTable(pstrCommand, StringConnections.BeloSalao, CommandType.StoredProcedure);
        
        }
        /// <summary>
        /// Retorna o resultado de um comando SQL (Procedure e Transact-SQL) em um DataTable.
        /// </summary>
        /// <param name="pstrCommand">Comando SQL (Procedure ou Transact-SQL)</param>            
        /// <param name="peConnection">Nome da string de Conexão no Web.Config</param>            
        /// <returns>DataTable com o resultado do comando SQL.</returns>
        protected DataTable ExecuteDataTable(string pstrCommand, StringConnections peConnection)
        {
            return ExecuteDataTable(pstrCommand, peConnection, CommandType.StoredProcedure);
        }
        /// <summary>
        /// Retorna o resultado de um comando SQL (Procedure e Transact-SQL) em um DataTable.
        /// </summary>
        /// <param name="pstrCommand">Comando SQL (Procedure ou Transact-SQL)</param>                        
        /// <param name="peType">Tipo de comando a ser executado</param>
        /// <returns>DataTable com o resultado do comando SQL.</returns>
        protected DataTable ExecuteDataTable(string pstrCommand, CommandType peType)
        {
            return ExecuteDataTable(pstrCommand, StringConnections.BeloSalao, peType);
        }
        /// <summary>
        /// Retorna o resultado de um comando SQL (Procedure e Transact-SQL) em um DataTable.
        /// </summary>
        /// <param name="pstrCommand">Comando SQL (Procedure ou Transact-SQL)</param>            
        /// <param name="peConnection">Nome da string de Conexão no Web.Config</param>
        /// <param name="peType">Tipo de comando a ser executado</param>
        /// <returns>DataTable com o resultado do comando SQL.</returns>
        protected DataTable ExecuteDataTable(string pstrCommand, StringConnections peConnection, CommandType peType)
        {
            MySqlConnection lcnnCon = RetornarConexao(peConnection);//objeto de conexão                
            MySqlDataAdapter ldapFill = new MySqlDataAdapter(_cmdCommand);
            DataTable dtbRetorno; //DataTable de retorno

            try
            {
                lcnnCon.Open();
                _cmdCommand.Connection = lcnnCon;
                _cmdCommand.CommandText = pstrCommand;
                _cmdCommand.CommandType = peType;

                dtbRetorno = new DataTable();
                ldapFill.Fill(dtbRetorno);
            }
            catch (Exception Ex)
            {
                throw Ex;
            }
            finally
            {
                if (ldapFill != null) ldapFill.Dispose();
                if (lcnnCon != null && lcnnCon.State != ConnectionState.Closed)
                {
                    lcnnCon.Close();
                    lcnnCon.Dispose();
                }
            }
            return dtbRetorno;
        }

        /// Retorna o resultado de um comando SQL (Procedure e Transact-SQL) em um DataTable.
        /// </summary>
        /// <param name="pstrCommand">Comando SQL (Procedure ou Transact-SQL)</param>                        
        /// <param name="ParametersCollection_">Coleções de parâmetros</param>            
        /// <returns>Resultado da primeira linha e coluna do comando SQL.</returns>
        public static DataTable ExecuteDataTable(string strCommand_, ref DataAccessParametersCollection ParametersCollection_)
        {
            return ExecuteDataTable(strCommand_, StringConnections.BeloSalao, CommandType.StoredProcedure, ref ParametersCollection_);
        }
        /// <summary>
        /// Retorna o resultado de um comando SQL (Procedure e Transact-SQL) em um DataTable.
        /// </summary>
        /// <param name="pstrCommand">Comando SQL (Procedure ou Transact-SQL)</param>            
        /// <param name="peConnection">Nome da string de Conexão no Web.Config</param>            
        /// <param name="ParametersCollection_">Coleções de parâmetros</param>            
        /// <returns>Resultado da primeira linha e coluna do comando SQL.</returns>
        public static DataTable ExecuteDataTable(string strCommand_, StringConnections eConnection_, ref DataAccessParametersCollection ParametersCollection_)
        {
            return ExecuteDataTable(strCommand_, eConnection_, CommandType.StoredProcedure, ref ParametersCollection_);
        }
        /// <summary>
        /// Retorna o resultado de um comando SQL (Procedure e Transact-SQL) em um DataTable.
        /// </summary>
        /// <param name="pstrCommand">Comando SQL (Procedure ou Transact-SQL)</param>                        
        /// <param name="peType">Tipo de comando a ser executado</param>
        /// <param name="ParametersCollection_">Coleções de parâmetros</param>            
        /// <returns>Resultado da primeira linha e coluna do comando SQL.</returns>
        public static DataTable ExecuteDataTable(string strCommand_, CommandType eType_, ref DataAccessParametersCollection ParametersCollection_)
        {
            return ExecuteDataTable(strCommand_, StringConnections.BeloSalao, eType_, ref ParametersCollection_);
        }
        /// <summary>
        /// Retorna o resultado de um comando SQL (Procedure e Transact-SQL) em um DataTable.
        /// </summary>
        /// <param name="pstrCommand">Comando SQL (Procedure ou Transact-SQL)</param>            
        /// <param name="peConnection">Nome da string de Conexão no Web.Config</param>
        /// <param name="peType">Tipo de comando a ser executado</param>
        /// <param name="ParametersCollection_">Coleções de parâmetros</param>            
        /// <returns>Resultado da primeira linha e coluna do comando SQL.</returns>
        public static DataTable ExecuteDataTable(string strCommand_, StringConnections eConnection_, CommandType eType_, ref DataAccessParametersCollection ParametersCollection_)
        {
            MySqlConnection cnnCon = RetornarConexao(eConnection_); //objeto de conexão
            MySqlCommand cmdCommand = ParametersCollection_.DataCommand;
            MySqlDataAdapter dapFill = new MySqlDataAdapter(cmdCommand);
            DataTable dtbRetorno; //DataTable de retorno

            try
            {
                cnnCon.Open();
                cmdCommand.Connection = cnnCon;
                cmdCommand.CommandText = strCommand_;
                cmdCommand.CommandType = eType_;

                dtbRetorno = new DataTable();
                dapFill.Fill(dtbRetorno);
            }
            catch (Exception Ex)
            {
                throw Ex;
            }
            finally
            {
                if (cnnCon != null && cnnCon.State != ConnectionState.Closed)
                {
                    cnnCon.Close();
                    cnnCon.Dispose();
                }
            }
            return dtbRetorno;
        }
        /// <summary>
        /// Retorna apenas a primeira linha e coluna do comando SQL.
        /// </summary>
        /// <param name="pstrCommand">Comando SQL (Procedure ou Transact-SQL)</param>            
        /// <returns>Resultado da primeira linha e coluna do comando SQL.</returns>
        protected object ExecuteScalar(string pstrCommand)
        {
            return ExecuteScalar(pstrCommand, StringConnections.BeloSalao, CommandType.StoredProcedure);
        }
        /// <summary>
        /// Retorna apenas a primeira linha e coluna do comando SQL.
        /// </summary>
        /// <param name="pstrCommand">Comando SQL (Procedure ou Transact-SQL)</param>            
        /// <param name="peConnection">Nome da string de Conexão no Web.Config</param>            
        /// <returns>Resultado da primeira linha e coluna do comando SQL.</returns>
        protected object ExecuteScalar(string pstrCommand, StringConnections peConnection)
        {
            return ExecuteScalar(pstrCommand, peConnection, CommandType.StoredProcedure);
        }
        /// <summary>
        /// Retorna apenas a primeira linha e coluna do comando SQL.
        /// </summary>
        /// <param name="pstrCommand">Comando SQL (Procedure ou Transact-SQL)</param>                        
        /// <param name="peType">Tipo de comando a ser executado</param>
        /// <returns>Resultado da primeira linha e coluna do comando SQL.</returns>
        protected object ExecuteScalar(string pstrCommand, CommandType peType)
        {
            return ExecuteScalar(pstrCommand, StringConnections.BeloSalao, peType);
        }
        /// <summary>
        /// Retorna apenas a primeira linha e coluna do comando SQL.
        /// </summary>
        /// <param name="strCommand_">Comando SQL (Procedure ou Transact-SQL</param>            
        /// <param name="trTransaction_">Objeto de transação</param>
        /// <returns>Resultado da primeira linha e coluna do comando SQL.</returns>
        protected object ExecuteScalar(string strCommand_, DataTransaction trTransaction_)
        {
            return ExecuteScalar(strCommand_, CommandType.StoredProcedure, trTransaction_);
        }
        /// <summary>
        /// Retorna apenas a primeira linha e coluna do comando SQL.
        /// </summary>
        /// <param name="strCommand_">Comando SQL (Procedure ou Transact-SQL</param>
        /// <param name="eType_">Tipo de comando a ser executado</param>
        /// <param name="trTransaction_">Objeto de transação</param>
        /// <returns>Resultado da primeira linha e coluna do comando SQL.</returns>
        protected object ExecuteScalar(string strCommand_, CommandType eType_, DataTransaction trTransaction_)
        {
            object objRetorno; //objeto de retorno

            CopiarParametros(ref trTransaction_);
            trTransaction_.Command.CommandText = strCommand_;
            trTransaction_.Command.CommandType = eType_;
            trTransaction_.Command.CommandTimeout = _cmdCommand.CommandTimeout;
            objRetorno = trTransaction_.Command.ExecuteScalar();
            AtualizarParametros(trTransaction_);
            return objRetorno;
        }
        /// <summary>
        /// Retorna apenas a primeira linha e coluna do comando SQL.
        /// </summary>
        /// <param name="pstrCommand">Comando SQL (Procedure ou Transact-SQL)</param>            
        /// <param name="peConnection">Nome da string de Conexão no Web.Config</param>
        /// <param name="peType">Tipo de comando a ser executado</param>
        /// <returns>Resultado da primeira linha e coluna do comando SQL.</returns>
        protected object ExecuteScalar(string pstrCommand, StringConnections peConnection, CommandType peType)
        {
            MySqlConnection lcnnCon = RetornarConexao(peConnection);//objeto de conexão                
            object objRetorno; //objeto de retorno

            try
            {
                lcnnCon.Open();
                _cmdCommand.Connection = lcnnCon;
                _cmdCommand.CommandText = pstrCommand;
                _cmdCommand.CommandType = peType;
                objRetorno = _cmdCommand.ExecuteScalar();
            }
            catch (Exception Ex)
            {
                throw Ex;
            }
            finally
            {
                if (lcnnCon != null && lcnnCon.State != ConnectionState.Closed)
                {
                    lcnnCon.Close();
                    lcnnCon.Dispose();
                }
            }
            return objRetorno;
        }
        /// <summary>
        /// Retorna apenas a primeira linha e coluna do comando SQL.
        /// </summary>
        /// <param name="pstrCommand">Comando SQL (Procedure ou Transact-SQL)</param>                        
        /// <param name="ParametersCollection_">Coleções de parâmetros</param>            
        /// <returns>Resultado da primeira linha e coluna do comando SQL.</returns>
        public static object ExecuteScalar(string strCommand_, ref DataAccessParametersCollection ParametersCollection_)
        {
            return ExecuteScalar(strCommand_, StringConnections.BeloSalao, CommandType.StoredProcedure, ref ParametersCollection_);
        }
        /// <summary>
        /// Retorna apenas a primeira linha e coluna do comando SQL.
        /// </summary>
        /// <param name="pstrCommand">Comando SQL (Procedure ou Transact-SQL)</param>            
        /// <param name="peConnection">Nome da string de Conexão no Web.Config</param>            
        /// <param name="ParametersCollection_">Coleções de parâmetros</param>            
        /// <returns>Resultado da primeira linha e coluna do comando SQL.</returns>
        public static object ExecuteScalar(string strCommand_, StringConnections eConnection_, ref DataAccessParametersCollection ParametersCollection_)
        {
            return ExecuteScalar(strCommand_, eConnection_, CommandType.StoredProcedure, ref ParametersCollection_);
        }
        /// <summary>
        /// Retorna apenas a primeira linha e coluna do comando SQL.
        /// </summary>
        /// <param name="pstrCommand">Comando SQL (Procedure ou Transact-SQL)</param>                        
        /// <param name="peType">Tipo de comando a ser executado</param>
        /// <param name="ParametersCollection_">Coleções de parâmetros</param>            
        /// <returns>Resultado da primeira linha e coluna do comando SQL.</returns>
        public static object ExecuteScalar(string strCommand_, CommandType eType_, ref DataAccessParametersCollection ParametersCollection_)
        {
            return ExecuteScalar(strCommand_, StringConnections.BeloSalao, eType_, ref ParametersCollection_);
        }
        /// <summary>
        /// Retorna apenas a primeira linha e coluna do comando SQL.
        /// </summary>
        /// <param name="pstrCommand">Comando SQL (Procedure ou Transact-SQL)</param>            
        /// <param name="peConnection">Nome da string de Conexão no Web.Config</param>
        /// <param name="peType">Tipo de comando a ser executado</param>
        /// <param name="ParametersCollection_">Coleções de parâmetros</param>            
        /// <returns>Resultado da primeira linha e coluna do comando SQL.</returns>
        public static object ExecuteScalar(string strCommand_, StringConnections eConnection_, CommandType eType_, ref DataAccessParametersCollection ParametersCollection_)
        {
            MySqlConnection cnnCon = RetornarConexao(eConnection_);//objeto de conexão
            MySqlCommand cmdCommand = ParametersCollection_.DataCommand;
            object objRetorno; //objeto de retorno

            try
            {
                cnnCon.Open();
                cmdCommand.Connection = cnnCon;
                cmdCommand.CommandText = strCommand_;
                cmdCommand.CommandType = eType_;
                objRetorno = cmdCommand.ExecuteScalar();
            }
            catch (Exception Ex)
            {
                throw Ex;
            }
            finally
            {
                if (cnnCon != null && cnnCon.State != ConnectionState.Closed)
                {
                    cnnCon.Close();
                    cnnCon.Dispose();
                }
            }
            return objRetorno;
        }
        /// <summary>
        /// Executa um comando SQL.
        /// </summary>
        /// <param name="pstrCommand">Comando SQL (Procedure ou Transact-SQL)</param>            
        /// <returns>O número de linhas afetadas</returns>
        protected int ExecuteNonQuery(string pstrCommand)
        {
            return ExecuteNonQuery(pstrCommand, StringConnections.BeloSalao, CommandType.StoredProcedure);
        }
        /// <summary>
        /// Executa um comando SQL.
        /// </summary>
        /// <param name="pstrCommand">Comando SQL (Procedure ou Transact-SQL)</param>            
        /// <param name="peConnection">Nome da string de Conexão no Web.Config</param>            
        /// <returns>O número de linhas afetadas</returns>
        protected int ExecuteNonQuery(string pstrCommand, StringConnections peConnection)
        {
            return ExecuteNonQuery(pstrCommand, peConnection, CommandType.StoredProcedure);
        }
        /// <summary>
        /// Executa um comando SQL.
        /// </summary>
        /// <param name="pstrCommand">Comando SQL (Procedure ou Transact-SQL)</param>                        
        /// <param name="peType">Tipo de comando a ser executado</param>
        /// <returns>O número de linhas afetadas</returns>
        protected int ExecuteNonQuery(string pstrCommand, CommandType peType)
        {
            return ExecuteNonQuery(pstrCommand, StringConnections.BeloSalao, peType);
        }

        /// <summary>
        /// Executa um comando SQL.
        /// </summary>
        /// <param name="strCommand_">Comando SQL (Procedure ou Transact-SQL)</param>                        
        /// <param name="trTransaction_">Objeto de transação</param>
        /// <returns>O número de linhas afetadas</returns>
        protected int ExecuteNonQuery(string strCommand_, DataTransaction trTransaction_)
        {

            return ExecuteNonQuery(strCommand_, CommandType.StoredProcedure, trTransaction_);
        }

        /// <summary>
        /// Executa um comando SQL.
        /// </summary>
        /// <param name="strCommand_">Comando SQL (Procedure ou Transact-SQL)</param>                        
        /// <param name="eType_">Tipo de comando a ser executado</param>
        /// <param name="trTransaction_">Objeto de transação</param>
        /// <returns>O número de linhas afetadas</returns>
        protected int ExecuteNonQuery(string strCommand_, CommandType eType_, DataTransaction trTransaction_)
        {
            int lintRetorno; //objeto de retorno
            CopiarParametros(ref trTransaction_);
            trTransaction_.Command.CommandText = strCommand_;
            trTransaction_.Command.CommandType = eType_;
            trTransaction_.Command.CommandTimeout = _cmdCommand.CommandTimeout;
            lintRetorno = trTransaction_.Command.ExecuteNonQuery();
            AtualizarParametros(trTransaction_);
            return lintRetorno;
        }
        /// <summary>
        /// Executa um comando SQL.
        /// </summary>
        /// <param name="pstrCommand">Comando SQL (Procedure ou Transact-SQL)</param>            
        /// <param name="peConnection">Nome da string de Conexão no Web.Config</param>
        /// <param name="peType">Tipo de comando a ser executado</param>
        /// <returns>O número de linhas afetadas</returns>
        protected int ExecuteNonQuery(string pstrCommand, StringConnections peConnection, CommandType peType)
        {
            MySqlConnection lcnnCon = RetornarConexao(peConnection); //objeto de conexão
            int lintRetorno; //objeto de retorno

            try
            {
                lcnnCon.Open();
                _cmdCommand.Connection = lcnnCon;
                _cmdCommand.CommandText = pstrCommand;
                _cmdCommand.CommandType = peType;
                lintRetorno = _cmdCommand.ExecuteNonQuery();
            }
            catch (Exception Ex)
            {
                throw Ex;
            }
            finally
            {
                if (lcnnCon != null && lcnnCon.State != ConnectionState.Closed)
                {
                    lcnnCon.Close();
                    lcnnCon.Dispose();
                }
            }
            return lintRetorno;
        }

        /// <summary>
        /// Executa um comando SQL.
        /// </summary>
        /// <param name="strCommand_">Comando SQL (Procedure ou Transact-SQL)</param>            
        /// <param name="eType_">Tipo de comando a ser executado</param>
        /// <param name="ParametersCollection_">Coleções de parâmetros</param>            
        /// <returns>Tipo de comando a ser executado</returns>
        public static int ExecuteNonQuery(string strCommand_, CommandType eType_, ref DataAccessParametersCollection ParametersCollection_)
        {
            return ExecuteNonQuery(strCommand_, StringConnections.BeloSalao, eType_, ref ParametersCollection_);
        }

        /// <summary>
        /// Executa um comando SQL.
        /// </summary>
        /// <param name="strCommand_">Comando SQL (Procedure ou Transact-SQL)</param>
        /// <param name="eConnection_">Nome da string de Conexão no Web.Config</param>
        /// <param name="eType_">Tipo de comando a ser executado</param>
        /// <param name="ParametersCollection_">Coleções de parâmetros</param>            
        /// <returns>Tipo de comando a ser executado</returns>
        public static int ExecuteNonQuery(string strCommand_, ref DataAccessParametersCollection ParametersCollection_)
        {
            return ExecuteNonQuery(strCommand_, StringConnections.BeloSalao, CommandType.StoredProcedure, ref ParametersCollection_);
        }

        /// <summary>
        /// Executa um comando SQL.
        /// </summary>
        /// <param name="strCommand_">Comando SQL (Procedure ou Transact-SQL)</param>
        /// <param name="eConnection_">Nome da string de Conexão no Web.Config</param>
        /// <param name="eType_">Tipo de comando a ser executado</param>
        /// <param name="ParametersCollection_">Coleções de parâmetros</param>            
        /// <returns>Tipo de comando a ser executado</returns>
        public static int ExecuteNonQuery(string strCommand_, StringConnections eConnection_, CommandType eType_, ref DataAccessParametersCollection ParametersCollection_)
        {
            MySqlConnection cnnCon = RetornarConexao(eConnection_);//objeto de conexão
            MySqlCommand cmdCommand = ParametersCollection_.DataCommand;
            int lintRetorno; //objeto de retorno

            try
            {
                cnnCon.Open();
                cmdCommand.Connection = cnnCon;
                cmdCommand.CommandText = strCommand_;
                cmdCommand.CommandType = eType_;
                lintRetorno = cmdCommand.ExecuteNonQuery();
            }
            catch (Exception Ex)
            {
                throw Ex;
            }
            finally
            {
                if (cnnCon != null && cnnCon.State != ConnectionState.Closed)
                {
                    cnnCon.Close();
                    cnnCon.Dispose();
                }
            }
            return lintRetorno;
        }

        #endregion

        /// <summary>
        /// Connections Strings disponíveis
        /// </summary>
        public enum StringConnections
        {
            BeloSalao = 0,
            Connection1 = 1,
            Connection2 = 2,
            Connection3 = 3,
            Connection4 = 4,
            Connection5 = 5,
            Salao = 6
        }

        /// <summary>
        /// Define uma coleção de parâmetros (Utilize somente quando utlizar os métodos estáticos de acesso a banco).
        /// </summary>
        public class DataAccessParametersCollection : IDisposable
        {
            #region Campos
            MySqlCommand _cmdCommand;//Objeto command para executar comandos SQL no banco
            #endregion

            #region IDisposable Members
            [NonSerialized]
            private bool Disposed = false;
            /// <summary>
            /// Destructor da classe. Executa o método Dispose() para liberar recursos.
            /// </summary>
            ~DataAccessParametersCollection()
            {
                this.Dispose(false);
            }

            /// <summary>
            /// Libera os recursos usados pela classe. Implementa o método Dispose().
            /// </summary>
            public void Dispose()
            {
                // Para o garbage collector para limpesa. Cleaning up twice.
                Dispose(true);
                GC.SuppressFinalize(this);
            }

            /// <summary>
            /// Libera os recursos usados pela classe. Evita que um objeto seja liberado duas vezes.
            /// </summary>
            /// <param name="disposing"></param>
            private void Dispose(bool disposing)
            {
                // Executa tarefas de limpesa antes de finalizar a classe.
                if (!this.Disposed)
                {
                    if (disposing)
                    {
                        _cmdCommand.Dispose();
                    }
                    //free unmanaged resources
                }
                Disposed = true;
            }
            #endregion

            #region Contrutores
            /// <summary>
            /// Inicializa a classe
            /// </summary>
            public DataAccessParametersCollection()
            {
                _cmdCommand = new MySqlCommand();
                _cmdCommand.CommandTimeout = DataAccess.DataAccessCommandTimeout;
            }

            /// <summary>
            /// Inicializa a classe definindo um Timeout para os comandos SQL
            /// </summary>
            /// <param name="intCommandTimeout_">Timeout para os comandos SQL</param>
            public DataAccessParametersCollection(int intCommandTimeout_)
            {
                _cmdCommand = new MySqlCommand();
                _cmdCommand.CommandTimeout = intCommandTimeout_;
            }
            #endregion

            #region Propriedades
            internal MySqlCommand DataCommand
            {
                get
                {
                    return _cmdCommand;
                }
            }

            /// <summary>
            /// Permite cria parâmetros para métodos estaticos
            /// </summary>
            public MySqlParameterCollection DataAccessParameters
            {
                get
                {
                    return _cmdCommand.Parameters;
                }
            }
            #endregion
        }
    }
}
